home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / program / pdmake.arc / RULES.C < prev    next >
C/C++ Source or Header  |  1986-12-15  |  10KB  |  356 lines
  1.     /***************************************************************\
  2.     *                                *
  3.     *  PDMAKE, Atari ST version                    *
  4.     *                                *
  5.     *  Adapted from mod.sources Vol 7 Issue 71, 1986-12-03.        *
  6.     *                                *
  7.     *  This port makes extensive use of the original net.sources    *
  8.     *  port by Jwahar Bammi.                    *
  9.     *                                *
  10.     *      Ton van Overbeek                        *
  11.     *      Email: TPC862@ESTEC.BITNET                *
  12.     *             TPC862%ESTEC.BITNET@WISCVM.WISC.EDU    (ARPA)    *
  13.     *             ...!mcvax!tpc862%estec.bitnet   (UUCP Europe)    *
  14.     *             ...!ucbvax!tpc862%estec.bitnet  (UUCP U.S.A.)    *
  15.     *             71450,3537  (CompuServe)                *
  16.     *                                *
  17.     \***************************************************************/
  18.  
  19. /*
  20.  *    Control of the implicit suffix rules
  21.  */
  22.  
  23.  
  24. #include "h.h"
  25.  
  26.  
  27. /*
  28.  *    Return a pointer to the suffix of a name
  29.  */
  30. char *
  31. suffix(name)
  32. char *    name;
  33. {
  34.     return rindex(name, '.');
  35. }
  36.  
  37.  
  38. /*
  39.  *    Dynamic dependency.  This routine applies the suffix rules
  40.  *    to try and find a source and a set of rules for a missing
  41.  *    target.  If found, np is made into a target with the implicit
  42.  *    source name, and rules.  Returns TRUE if np was made into
  43.  *    a target.
  44.  */
  45. bool
  46. dyndep(np)
  47. struct name *    np;
  48. {
  49.     register char *    p;
  50.     register char *    q;
  51.     register char *    suff;        /*  Old suffix  */
  52.     register char *    basename;    /*  Name without suffix  */
  53.     struct name *    op;        /*  New dependent  */
  54.     struct name *    sp;        /*  Suffix  */
  55.     struct line *    lp;
  56.     struct depend *    dp;
  57.     char *        newsuff;
  58.  
  59.  
  60.     p = str1;
  61.     q = np->n_name;
  62.     if (!(suff = suffix(q)))
  63.         return FALSE;            /* No suffix */
  64.     while (q < suff)
  65.         *p++ = *q++;
  66.     *p = '\0';
  67.     basename = setmacro("*", str1)->m_val;
  68.  
  69.     if (!((sp = newname(".SUFFIXES"))->n_flag & N_TARG))
  70.         return FALSE;
  71.  
  72.     for (lp = sp->n_line; lp; lp = lp->l_next)
  73.         for (dp = lp->l_dep; dp; dp = dp->d_next)
  74.         {
  75.             newsuff = dp->d_name->n_name;
  76.             if (strlen(suff)+strlen(newsuff)+1 >= LZ)
  77.                 fatal("Suffix rule too long");
  78.             p = str1;
  79.             q = newsuff;
  80.             while (*p++ = *q++)
  81.                 ;
  82.             p--;
  83.             q = suff;
  84.             while (*p++ = *q++)
  85.                 ;
  86.             sp = newname(str1);
  87.             if (sp->n_flag & N_TARG)
  88.             {
  89.                 p = str1;
  90.                 q = basename;
  91.                 if (strlen(basename) + strlen(newsuff)+1 >= LZ)
  92.                     fatal("Implicit name too long");
  93.                 while (*p++ = *q++)
  94.                     ;
  95.                 p--;
  96.                 q = newsuff;
  97.                 while (*p++ = *q++)
  98.                     ;
  99.                 op = newname(str1);
  100.                 if (!op->n_time)
  101.                     modtime(op);
  102.                 if (op->n_time)
  103.                 {
  104.                     dp = newdep(op, (struct depend *) 0);
  105.                     newline(np, dp, sp->n_line->l_cmd, 0);
  106.                     setmacro("<", op->n_name);
  107.                     return TRUE;
  108.                 }
  109.             }
  110.         }
  111.     return FALSE;
  112. }
  113.  
  114.  
  115. /*
  116.  *    Make the default rules
  117.  */
  118. void
  119. makerules()
  120. {
  121.     struct cmd *    cp;
  122.     struct name *    np;
  123.     struct depend *    dp;
  124.  
  125.  
  126. #ifdef eon
  127.     setmacro("BDSCC", "asm");
  128.     /*    setmacro("BDSCFLAGS", "");    */
  129.     cp = newcmd("$(BDSCC) $(BDSCFLAGS) -n $<", (struct cmd *) 0);
  130.     np = newname(".c.o");
  131.     newline(np, (struct depend *) 0, cp, 0);
  132.  
  133.     setmacro("CC", "c");
  134.     setmacro("CFLAGS", "-O");
  135.     cp = newcmd("$(CC) $(CFLAGS) -c $<", (struct cmd *) 0);
  136.     np = newname(".c.obj");
  137.     newline(np, (struct depend *) 0, cp, 0);
  138.  
  139.     setmacro("M80", "asm -n");
  140.     /*    setmacro("M80FLAGS", "");    */
  141.     cp = newcmd("$(M80) $(M80FLAGS) $<", (struct cmd *) 0);
  142.     np = newname(".mac.o");
  143.     newline(np, (struct depend *) 0, cp, 0);
  144.  
  145.  
  146.     setmacro("AS", "zas");
  147.     /*    setmacro("ASFLAGS", "");    */
  148.     cp = newcmd("$(ZAS) $(ASFLAGS) -o $@ $<", (struct cmd *) 0);
  149.     np = newname(".as.obj");
  150.     newline(np, (struct depend *) 0, cp, 0);
  151.  
  152.     np = newname(".as");
  153.     dp = newdep(np, 0);
  154.     np = newname(".obj");
  155.     dp = newdep(np, dp);
  156.     np = newname(".c");
  157.     dp = newdep(np, dp);
  158.     np = newname(".o");
  159.     dp = newdep(np, dp);
  160.     np = newname(".mac");
  161.     dp = newdep(np, dp);
  162.     np = newname(".SUFFIXES");
  163.     newline(np, (struct depend *) 0, cp, 0);
  164. #endif
  165.  
  166. /*
  167.  *    Some of the UNIX implicit rules
  168.  */
  169. #ifdef unix
  170.     setmacro("CC", "cc");
  171.     setmacro("CFLAGS", "-O");
  172.     cp = newcmd("$(CC) $(CFLAGS) -c $<", (struct cmd *) 0);
  173.     np = newname(".c.o");
  174.     newline(np, (struct depend *) 0, cp, 0);
  175.  
  176.     setmacro("AS", "as");
  177.     cp = newcmd("$(AS) -o $@ $<", (struct cmd *) 0);
  178.     np = newname(".s.o");
  179.     newline(np, (struct depend *) 0, cp, 0);
  180.  
  181.     setmacro("YACC", "yacc");
  182.     /*    setmacro("YFLAGS", "");    */
  183.     cp = newcmd("$(YACC) $(YFLAGS) $<", (struct cmd *) 0);
  184.     cp = newcmd("mv y.tab.c $@", cp);
  185.     np = newname(".y.c");
  186.     newline(np, (struct depend *) 0, cp, 0);
  187.  
  188.     cp = newcmd("$(YACC) $(YFLAGS) $<", (struct cmd *) 0);
  189.     cp = newcmd("$(CC) $(CFLAGS) -c y.tab.c", cp);
  190.     cp = newcmd("rm y.tab.c", cp);
  191.     cp = newcmd("mv y.tab.o $@", cp);
  192.     np = newname(".y.o");
  193.     newline(np, (struct depend *) 0, cp, 0);
  194.  
  195.     np = newname(".s");
  196.     dp = newdep(np, 0);
  197.     np = newname(".o");
  198.     dp = newdep(np, dp);
  199.     np = newname(".c");
  200.     dp = newdep(np, dp);
  201.     np = newname(".y");
  202.     dp = newdep(np, dp);
  203.     np = newname(".SUFFIXES");
  204.     newline(np, (struct depend *) 0, cp, 0);
  205. #endif
  206. #ifdef os9
  207. /*
  208.  *    Fairlight use an enhanced version of the C sub-system.
  209.  *    They have a specialised macro pre-processor.
  210.  */
  211.     setmacro("CC", "cc");
  212.     setmacro("CFLAGS", "-z");
  213.     cp = newcmd("$(CC) $(CFLAGS) -r $<", (struct cmd *) 0);
  214.  
  215.     np = newname(".c.r");
  216.     newline(np, (struct depend *) 0, cp, 0);
  217.     np = newname(".ca.r");
  218.     newline(np, (struct depend *) 0, cp, 0);
  219.     np = newname(".a.r");
  220.     newline(np, (struct depend *) 0, cp, 0);
  221.     np = newname(".o.r");
  222.     newline(np, (struct depend *) 0, cp, 0);
  223.     np = newname(".mc.r");
  224.     newline(np, (struct depend *) 0, cp, 0);
  225.     np = newname(".mca.r");
  226.     newline(np, (struct depend *) 0, cp, 0);
  227.     np = newname(".ma.r");
  228.     newline(np, (struct depend *) 0, cp, 0);
  229.     np = newname(".mo.r");
  230.     newline(np, (struct depend *) 0, cp, 0);
  231.  
  232.     np = newname(".r");
  233.     dp = newdep(np, 0);
  234.     np = newname(".mc");
  235.     dp = newdep(np, dp);
  236.     np = newname(".mca");
  237.     dp = newdep(np, dp);
  238.     np = newname(".c");
  239.     dp = newdep(np, dp);
  240.     np = newname(".ca");
  241.     dp = newdep(np, dp);
  242.     np = newname(".ma");
  243.     dp = newdep(np, dp);
  244.     np = newname(".mo");
  245.     dp = newdep(np, dp);
  246.     np = newname(".o");
  247.     dp = newdep(np, dp);
  248.     np = newname(".a");
  249.     dp = newdep(np, dp);
  250.     np = newname(".SUFFIXES");
  251.     newline(np, dp, (struct cmd *) 0, 0);
  252. #endif
  253.  
  254. #ifdef ATARIST
  255.     /* Atari special internal (to make) commands */
  256.     setmacro("RM","%r");    /* Remove, any number of args, Wildcards OK */
  257.     setmacro("CP","%c");    /* Copy file to file only     */
  258.     setmacro("ECHO","%e");    /* Echo Argument          */
  259.  
  260. #ifndef MEGRULES
  261.     /* Alcyon C and AS68 rules */
  262.  
  263.     /* Path to the Alcyon C executables */
  264.     setmacro("CPATH","a:");
  265.  
  266.     /* C preprocessor       */
  267.     setmacro("CP68", "cp68.prg");
  268.     /* C preprocessor flags    */
  269.     setmacro("CPFLAGS", "-i a:\\include\\");
  270.  
  271.     /* Pass 1 of the C compiler */
  272.     setmacro("C068", "c068.prg");
  273.     /* Pass 1 flags           */
  274.     setmacro("C0FLAGS", "-f");    /* change to "" if you want to use IEEE
  275.                  * floating point and libm instead of libf
  276.                  * by Default. Otherwise simply redefine
  277.                  * C0FLAGS in your makefile to get the
  278.                  * IEEE floating option.
  279.                  */
  280.  
  281.     /* Pass 2 of the C compiler */
  282.     setmacro("C168","c168.prg");
  283.     /* Pass 2  flags        */
  284.     /* setmacro("C1FLAGS", ""); */    /* Save ourselves some space */
  285.  
  286.     /*